import Vue from 'vue'
import VueRouter from 'vue-router'
import LoginPage from '@/components/LoginPage.vue'

Vue.use(VueRouter)

// 静态路由，不需要权限的路由
export const constantRoutes = [
  {
    path: '/',
    redirect: '/login'
  },
  {
    path: '/login',
    name: 'Login',
    meta: {
      title: '登录页面'
    },
    component: LoginPage
  },
  {
    path: '/404',
    meta: {
      title: '404'
    },
    component: () => import('@/components/error/404.vue'),
    hidden: true
  },
  {
    path: '/403',
    meta: {
      title: '403'
    },
    component: () => import('@/components/error/403.vue'),
    hidden: true
  }
]

// 创建router实例
const createRouter = () => new VueRouter({
  mode: 'history',
  base: process.env.BASE_URL,
  routes: constantRoutes
})

const router = createRouter()

// 重置路由方法
export function resetRouter() {
  console.log('开始重置路由...')
  
  // 获取所有路由
  const allRoutes = router.getRoutes()
  console.log('重置前的路由数量:', allRoutes.length)
  
  // 直接创建新的路由实例并替换当前的matcher
  const newRouter = createRouter()
  router.matcher = newRouter.matcher
  
  console.log('路由重置完成，当前路由数量:', router.getRoutes().length)
}

// 处理路由重复导航错误
const originalPush = VueRouter.prototype.push
VueRouter.prototype.push = function push(location) {
  return originalPush.call(this, location).catch(err => {
    if (err.name !== 'NavigationDuplicated') {
      return Promise.reject(err)
    }
    // 对于重复导航,返回一个resolved promise
    return Promise.resolve()
  })
}

// 全局路由守卫
router.beforeEach((to, from, next) => {
  console.log('路由拦截 - 当前路由:', to.path)
  
  // 如果是前往登录页或错误页，直接放行
  if (to.path === '/login' || to.path === '/404' || to.path === '/403') {
    console.log('访问公共页面，直接放行')
    next()
    return
  }
  
  // 检查是否已登录
  const isLoggedIn = localStorage.getItem('isLoggedIn') === 'true'
  const token = localStorage.getItem('jwt_token')
  
  // 未登录，重定向到登录页
  if (!isLoggedIn || !token) {
    console.log('用户未登录，重定向到登录页')
    next('/login')
    return
  }

  // 用户已登录，检查路由权限
  // 首先获取当前已注册的所有路由路径
  const registeredRoutes = router.getRoutes()
  const registeredPaths = registeredRoutes.map(route => route.path)
  console.log('当前已注册的路由路径:', registeredPaths)
  
  // 如果是统计页面，作为默认页面总是放行
  if (to.path === '/statistics') {
    console.log('访问统计页面，默认放行')
    next()
    return
  }
  
  // 如果当前路径已在路由表中注册，直接放行
  if (registeredPaths.includes(to.path)) {
    console.log('当前路径已注册，直接放行:', to.path)
    next()
    return
  }
  
  // 如果是访问根路径
  if (to.path === '/') {
    console.log('访问根路径，尝试重定向到菜单页面')
    // 尝试获取菜单数据
    const menuString = localStorage.getItem('permissionMenus')
    if (menuString) {
      try {
        const menus = JSON.parse(menuString)
        console.log('从localStorage获取的菜单:', menus)
        
        if (menus && menus.length > 0) {
          // 确保第一个菜单的路径格式正确
          let firstPath = menus[0].path
          if (firstPath && !firstPath.startsWith('/')) {
            firstPath = '/' + firstPath
          }
          console.log('重定向到第一个菜单路径:', firstPath)
          
          // 检查该路径是否已注册
          if (registeredPaths.includes(firstPath)) {
            next(firstPath)
          } else {
            // 如果路径未注册，可能需要重新加载动态路由
            console.log('菜单路径未注册，尝试重新加载动态路由')
            // 尝试重新加载动态路由
            import('@/store').then(store => {
              store.default.dispatch('permission/generateRoutes', menus)
                .then(() => {
                  // 等待路由更新
                  setTimeout(() => {
                    next({ ...to, replace: true })
                  }, 200)
                })
                .catch(err => {
                  console.error('重新加载动态路由失败:', err)
                  // 导航到统计页面作为后备方案
                  next('/statistics')
                })
            })
          }
        } else {
          // 如果没有菜单，但用户已登录，默认导航到统计页面
          console.log('菜单为空，导航到统计页面')
          next('/statistics')
        }
      } catch (e) {
        console.error('解析菜单数据失败:', e)
        next('/statistics')
      }
    } else {
      // 没有菜单数据，导航到统计页面
      console.log('没有菜单数据，导航到统计页面')
      next('/statistics')
    }
    return
  }
  
  // 检查是否在菜单中有对应权限
  const menuString = localStorage.getItem('permissionMenus')
  if (menuString) {
    try {
      const menus = JSON.parse(menuString)
      
      // 检查目标路径是否在菜单中
      const hasPathInMenu = checkPathInMenus(menus, to.path)
      
      if (hasPathInMenu) {
        console.log('路径在菜单中但未注册，尝试重新加载动态路由')
        // 尝试重新加载动态路由
        import('@/store').then(store => {
          store.default.dispatch('permission/generateRoutes', menus)
            .then(() => {
              // 等待路由更新
              setTimeout(() => {
                next({ ...to, replace: true })
              }, 200)
            })
            .catch(err => {
              console.error('重新加载动态路由失败:', err)
              next('/statistics')
            })
        })
      } else {
        console.warn('用户无权访问:', to.path)
        // 无权访问时导航到统计页面而不是404
        next('/statistics')
      }
    } catch (e) {
      console.error('解析菜单数据失败:', e)
      next('/statistics')
    }
  } else {
    // 没有菜单数据
    console.log('没有菜单数据，导航到统计页面')
    next('/statistics')
  }
})

// 检查路径是否存在于菜单中的辅助函数
function checkPathInMenus(menus, path) {
  if (!Array.isArray(menus)) return false
  
  // 规范化路径比较
  const normalizedPath = path.startsWith('/') ? path : '/' + path
  
  for (const menu of menus) {
    let menuPath = menu.path
    if (menuPath && !menuPath.startsWith('/')) {
      menuPath = '/' + menuPath
    }
    
    // 直接比较路径
    if (menuPath === normalizedPath) {
      return true
    }
    
    // 检查子菜单
    if (menu.children && menu.children.length > 0) {
      if (checkPathInMenus(menu.children, path)) {
        return true
      }
    }
  }
  
  return false
}

export default router 